go-micro 动态加载插件源码分析
（给Go开发大全加星标）
来源：惜朝_
https://juejin.cn/post/6844904106566352910
【导读】go语言如何实现不修改代码、动态加载？本文做了go-micro框架详细介绍。
源码分析
启动服务前，设定 MICRO_PLUGIN 环境变量指定 .so 文件路径，支持多个插件，逗号分割。程序启动前会读取 MICRO_PLUGIN 环境变量，并完成插件设定。
下面是其内部实现：
go-micro/service.go
func (s *service) Init(opts ...Option) {
...
// setup the plugins
for _, p := range strings.Split(os.Getenv("MICRO_PLUGIN"), ",") {
if len(p) == 0 {
continue
}
// load the plugin
c, err := plugin.Load(p)
if err != nil {
logger.Fatal(err)
}
// initialise the plugin
if err := plugin.Init(c); err != nil {
logger.Fatal(err)
}
}
复制代码
从上面的代码可以看出，service 初始化化的时候，读取 MICRO_PLUGIN 环境变量中指定的 .so 文件路径。并且调用 plugin 包，逐个 Init 。
下面我们看下 plugin 包的实现：
plugin ├── default.go ├── plugin.go └── template.go
0 directories, 3 files
plugin 包的实现非常简单，只有三个文件。
go-micro/plugin/plugin.go
// Plugin is a plugin loaded from a file
type Plugin interface {
// Initialise a plugin with the config
Init(c *Config) error
// Load loads a .so plugin at the given path
Load(path string) (*Config, error)
// Build a .so plugin with config at the path specified
Build(path string, c *Config) error
}
复制代码
plugin 包定义了这样一个接口
Init(c *Config) error方法用来注册插件；Load(path string) (*Config, error)用来加载一个 .so 文件，并返回一个 Config ；Build(path string, c *Config) error用来根据指定的 Config 变量生成一个 .so 文件。
go-micro 提供了一个默认的实现，在 go-micro/plugin/default.go 。
先来看一下默认实现的 Load 方法：
import (
//...
pg "plugin"
//...
)
// Load loads a plugin created with `go build -buildmode=plugin`
func (p *plugin) Load(path string) (*Config, error) {
plugin, err := pg.Open(path)
if err != nil {
return nil, err
}
s, err := plugin.Lookup("Plugin")
if err != nil {
return nil, err
}
pl, ok := s.(*Config)
if !ok {
return nil, errors.New("could not cast Plugin object")
}
return pl, nil
}
复制代码
Load 方法主要就是调用标准库 plugin open 一个 .so 文件，然后寻找 Plugin 这个变量，并通过类型断言它转换成 *Config 。Config 是 go-micro 定义的一个类型：
// Config is the plugin config
type Config struct {
// Name of the plugin e.g rabbitmq
Name string
// Type of the plugin e.g broker
Type string
// Path specifies the import path
Path string
// NewFunc creates an instance of the plugin
NewFunc interface{}
}
复制代码
关于标准库 plugin 的用法，这里不再描述可以查看源码文件，里面有用法说明。
package plugin
// Plugin is a loaded Go plugin.
type Plugin struct {
pluginpath string
err string // set if plugin failed to load
loaded chan struct{} // closed when loaded
syms map[string]interface{}
}
// Open opens a Go plugin.
// If a path has already been opened, then the existing *Plugin is returned.
// It is safe for concurrent use by multiple goroutines.
func Open(path string) (*Plugin, error) {
return open(path)
}
// Lookup searches for a symbol named symName in plugin p.
// A symbol is any exported variable or function.
// It reports an error if the symbol is not found.
// It is safe for concurrent use by multiple goroutines.
func (p *Plugin) Lookup(symName string) (Symbol, error) {
return lookup(p, symName)
}
// A Symbol is a pointer to a variable or function.
//
// For example, a plugin defined as
//
// package main
//
// import "fmt"
//
// var V int
//
// func F() { fmt.Printf("Hello, number %d\n", V) }
//
// may be loaded with the Open function and then the exported package
// symbols V and F can be accessed
//
// p, err := plugin.Open("plugin_name.so")
// if err != nil {
// panic(err)
// }
// v, err := p.Lookup("V")
// if err != nil {
// panic(err)
// }
// f, err := p.Lookup("F")
// if err != nil {
// panic(err)
// }
// *v.(*int) = 7
// f.(func())() // prints "Hello, number 7"
type Symbol interface{}
复制代码
我们继续看 go-micro 的 Init 方法实现：
// Init sets up the plugin
func (p *plugin) Init(c *Config) error {
switch c.Type {
case "broker":
pg, ok := c.NewFunc.(func(...broker.Option) broker.Broker)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultBrokers[c.Name] = pg
case "client":
pg, ok := c.NewFunc.(func(...client.Option) client.Client)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultClients[c.Name] = pg
case "registry":
pg, ok := c.NewFunc.(func(...registry.Option) registry.Registry)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultRegistries[c.Name] = pg
case "selector":
pg, ok := c.NewFunc.(func(...selector.Option) selector.Selector)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultSelectors[c.Name] = pg
case "server":
pg, ok := c.NewFunc.(func(...server.Option) server.Server)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultServers[c.Name] = pg
case "transport":
pg, ok := c.NewFunc.(func(...transport.Option) transport.Transport)
if !ok {
return fmt.Errorf("Invalid plugin %s", c.Name)
}
cmd.DefaultTransports[c.Name] = pg
default:
return fmt.Errorf("Unknown plugin type: %s for %s", c.Type, c.Name)
}
return nil
}
复制代码
这个函数是 micro 实现动态加载的重点，Init 函数通过 Load 方法返回的 Config 变量进行选择，然后通过类型转换得到 对应的构建函数赋值给 go-micro 的 cmd 包里的全局变量 DefaultXXXs 。
go-micro/config/cmd/cmd.go
DefaultBrokers = map[string]func(...broker.Option) broker.Broker{
"service": brokerSrv.NewBroker,
"memory": memory.NewBroker,
"nats": nats.NewBroker,
}
DefaultClients = map[string]func(...client.Option) client.Client{
"mucp": cmucp.NewClient,
"grpc": cgrpc.NewClient,
}
复制代码
以 DefaultClients 为例，假设我们实现了一个 client 插件(需要实现 go-micro 的 client.Client 接口) 并实现了自己的创建函数 xrpc.NewClient 。那加载插件成功后， DefaultClients 变量就是
map[string]func(...client.Option) client.Client{
"mucp": cmucp.NewClient,
"grpc": cgrpc.NewClient,
"xrpc": xrpc.NewClient,
}
复制代码
在 cmd 对象的 Before 方法中会根据程序启动时传入的参数来选择对应的插件。
go-micro/config/cmd/cmd.go
// Set the client
if name := ctx.String("client"); len(name) > 0 {
// only change if we have the client and type differs
if cl, ok := c.opts.Clients[name]; ok && (*c.opts.Client).String() != name {
*c.opts.Client = cl()
}
}
复制代码
GLOBAL OPTIONS: --client value Client for go-micro; rpc [$MICRO_CLIENT]
如果启动程序时设定了 client=xrpc ，必须记得设定 MICRO_PLUGIN 环境变量指定动态库。这里设定的 c.opts.Client 会被 micro 服务所使用，可以一步一步向上追溯，这里就不追踪了。
上面的源码分析中，我们没有看 go-micro plugin 包的 Build 方法默认实现，现在我们来看一下：
// Build generates a dso plugin using the go command `go build -buildmode=plugin`
func (p *plugin) Build(path string, c *Config) error {
path = strings.TrimSuffix(path, ".so")
// create go file in tmp path
temp := os.TempDir()
base := filepath.Base(path)
goFile := filepath.Join(temp, base+".go")
// generate .go file
if err := p.Generate(goFile, c); err != nil {
return err
}
// remove .go file
defer os.Remove(goFile)
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil && !os.IsExist(err) {
return fmt.Errorf("Failed to create dir %s: %v", filepath.Dir(path), err)
}
cmd := exec.Command("go", "build", "-buildmode=plugin", "-o", path+".so", goFile)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
}
复制代码
可以看出，主要就是更具传入的文件路径，创建目录，创建一个临时的go文件，然后调用 go build \-buildmode=plugin 生成动态库。
这里调用的一个 Generate 方法，这个方法通过 go 模版生成 go 文件。
// Generate creates a go file at the specified path.
// You must use `go build -buildmode=plugin`to build it.
func (p *plugin) Generate(path string, c *Config) error {
f, err := os.Create(path)
if err != nil {
return err
}
defer f.Close()
t, err := template.New(c.Name).Parse(tmpl)
if err != nil {
return err
}
return t.Execute(f, c)
}
// ...
var (
tmpl = `
package main
import (
"github.com/micro/go-micro/v2/plugin"
"{{.Path}}"
)
var Plugin = plugin.Config{
Name: "{{.Name}}",
Type: "{{.Type}}",
Path: "{{.Path}}",
NewFunc: {{.Name}}.{{.NewFunc}},
}
`
)
复制代码
根据模版生成 go 文件中会有一个全局变量 Plugin，这也印证了 Load 方法中的 plugin.Lookup("Plugin") 。
简单使用
package main
import (
"fmt"
"github.com/micro/go-micro/v2/plugin"
)
func main() {
p := plugin.NewPlugin()
if err := p.Build("/tmp/test.so", &plugin.Config{
Name: "client",
Type: "client",
Path: "github.com/micro/go-micro/v2/client",
NewFunc: "NewClient",
}); err != nil {
panic(err)
}
c, err := plugin.Load("/tmp/test.so")
if err != nil {
panic(err)
}
fmt.Println(c.Name, c.Type, c.Path, c.NewFunc)
}
复制代码
上面的例子，主要是使用了 go-micro 的 plugin 包。先生成了 /tmp/test.so ，然后在 Load 这个动态库，打印 config 的内容。
当然也可以，不通过 plugin.Build 生成动态库，直接手写一个 go 文件，手动编译成动态库。
test.go
package main
import (
"github.com/micro/go-micro/v2/client"
"github.com/micro/go-micro/v2/plugin"
)
var Plugin = plugin.Config{
Name: "test",
Type: "client",
Path: "github.com/micro/go-micro/v2/client",
NewFunc: client.NewClient,
}
复制代码
go build -buildmode=plugin -o ./test.so test.go
复制代码
go-micro 动态加载的主要场景
假设我们的 micro 服务 client 使用的是 grpc 的形式，现在希望改成 brpc 的形式。go-micro 支持的 client 插件中并不包含 brpc，我们自己使用 brpc 实现一个 client 插件，然后将其编译成动态库。
在运行环境 MICRO_PLUGIN 变量指定动态库路径，并且修改程序的启动命令，指定 client=brpc 。这样就可以做到无需重新编译二进制，替换自己想要的插件。
当然，自己在代码中重新 import 自己实现的插件库，显示指定 client 也是可以的。这样还可以将变更纳入版本管理，也是极好的。
- EOF -
Go 开发大全
参与维护一个非常全面的Go开源技术资源库。日常分享 Go, 云原生、k8s、Docker和微服务方面的技术文章和行业动态。
关注后获取
回复 Go 获取6万star的Go资源库
分享、点赞和在看
支持我们分享更多好文章，谢谢！